`:top
`!JavaFX`! ist ein `F33f`_`[Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Framework]`_`f zur Erstellung `F33f`_`[plattformübergreifender`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Plattformübergreifend]`_`f `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f-`F33f`_`[Applikationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anwendungssoftware]`_`f. Es ist eine `F33f`_`[Java-Spezifikation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java-Technologie]`_`f von `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle]`_`f und setzt sich zum Ziel, das professionelle Erstellen und Verteilen von `F33f`_`[interaktiven`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interaktivität]`_`f, `F33f`_`[multimedialen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Multimedia]`_`f Inhalten und `F33f`_`[grafischen Benutzeroberflächen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafische_Benutzeroberfläche]`_`f (GUIs) über sämtliche `F33f`_`[Java-Plattformen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java-Plattform]`_`f hinweg zu erleichtern.
Bis 2014 waren `F33f`_`[AWT`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Abstract_Window_Toolkit]`_`f und `F33f`_`[Swing`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Swing_(Java)]`_`f die Standardlösungen für grafische Anwendungen unter Java. Allerdings waren diese in die Jahre gekommen. So gab es Lücken im Bereich Medien und `F33f`_`[Animation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Animation]`_`f, was jedoch bei modernen grafischen Oberflächen heutzutage gefragt ist. Anstatt in die Weiterentwicklung von AWT/Swing zu investieren, entschied sich Oracle mit JavaFX für eine komplette Neuentwicklung der GUI-Ebene.
JavaFX setzt insbesondere auf einen `F33f`_`[Szenengraphen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Szenengraph]`_`f (engl. `*scene graph`*), der die einzelnen Bestandteile einer GUI verwaltet. Es ermöglicht mit FXML auch eine `F33f`_`[deklarative`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deklarative_Programmierung]`_`f Beschreibung von grafischen Oberflächen auf `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XML]`_`f-Basis. Mit dem Scene Builder existiert ein grafisches Tool, das die Erstellung von FXML-Dateien vereinfacht. Darüber hinaus können für die Gestaltung auch `F33f`_`[Web`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=World_Wide_Web]`_`f-Technologien wie `F33f`_`[CSS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cascading_Style_Sheets]`_`f eingesetzt werden, indem sie in den FXML-Code eingebettet werden.
Da JavaFX alle `F33f`_`[APIs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierschnittstelle]`_`f für moderne Oberflächen anbietet und auch nicht von AWT/Swing abhängig ist, bildet es einen kompletten Media-Stack. JavaFX greift direkt auf alle 2D-/3D-Fertigkeiten moderner `F33f`_`[Grafikprozessoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafikprozessor]`_`f zurück. So kann mit JavaFX auch all das programmiert werden, was bisher vorzugsweise mit `F33f`_`[Flash`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Adobe_Flash]`_`f realisiert wurde.`:cite-ref-inselbuch1011-2-0[`F5bf`_`[2`#cite-note-inselbuch1011-2]`_`f]
Die `*JavaFX-Laufzeitumgebung`* war von Version `F33f`_`[Java SE Runtime 7 Update 6`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java-Laufzeitumgebung]`_`f`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f] bis 10`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f] Teil jeder x86 Java SE Installation.
>>Contents
• `F0af`_`[Entwicklungsgeschichte`#entwicklungsgeschichte]`_`f
• `F0af`_`[Version 1`#version-1]`_`f
• `F0af`_`[Version 2`#version-2]`_`f
• `F0af`_`[Version 8`#version-8]`_`f
• `F0af`_`[Roadmap`#roadmap]`_`f
• `F0af`_`[Architektur`#architektur]`_`f
• `F0af`_`[Aufbau einer JavaFX-Anwendung`#aufbau-einer-javafx-anwendung]`_`f
• `F0af`_`[JavaFX-Lebenszyklus`#javafx-lebenszyklus]`_`f
• `F0af`_`[Die Stage (Bühne)`#die-stage-b-hne]`_`f
• `F0af`_`[Die Scene (Szene)`#die-scene-szene]`_`f
• `F0af`_`[Nodes (Knoten)`#nodes-knoten]`_`f
• `F0af`_`[Programmbeispiele`#programmbeispiele]`_`f
• `F0af`_`[Ereignisbehandlung`#ereignisbehandlung]`_`f
• `F0af`_`[JavaFX-Events`#javafx-events]`_`f
• `F0af`_`[Eventhandler`#eventhandler]`_`f
• `F0af`_`[Dynamische Datenstrukturen mit Änderungsmeldungen`#dynamische-datenstrukturen-mit-nderungsmeldungen]`_`f
• `F0af`_`[Properties und Data Binding`#properties-und-data-binding]`_`f
• `F0af`_`[Deklarative GUI-Beschreibungen`#deklarative-gui-beschreibungen]`_`f
• `F0af`_`[FXML`#fxml]`_`f
• `F0af`_`[Der Scene Builder`#der-scene-builder]`_`f
• `F0af`_`[FXGraph`#fxgraph]`_`f
• `F0af`_`[Kritik`#kritik]`_`f
• `F0af`_`[Literatur`#literatur]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f
• `F0af`_`[Anmerkungen`#anmerkungen]`_`f
-─
>>Entwicklungsgeschichte
Die Geschichte von JavaFX ist nicht besonders geradlinig. Ursprünglich wollte `F33f`_`[Sun`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sun_Microsystems]`_`f / `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle]`_`f JavaFX als `F33f`_`[Flash`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Adobe_Flash]`_`f-Ersatz im Internet positionieren, jedoch war die Kombination aus `F33f`_`[HTML5`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=HTML5]`_`f und `F33f`_`[CSS3`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cascading_Style_Sheets]`_`f und `F33f`_`[JavaScript`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JavaScript]`_`f zu attraktiv. Heutzutage ist es vor allem ein `F33f`_`[GUI-Toolkit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GUI-Toolkit]`_`f für klassische `F33f`_`[Client-Anwendungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Client-Anwendung]`_`f.`:cite-ref-inselbuch1011-2-1[`F5bf`_`[2`#cite-note-inselbuch1011-2]`_`f]
>>>Version 1
JavaFX wurde im Mai 2007 angekündigt und im Mai des folgenden Jahres auf der Entwicklerkonferenz `F33f`_`[JavaOne`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JavaOne]`_`f vorgestellt. Am 4. Dezember 2008 gab Sun JavaFX 1.0 offiziell als Entwickler-Kit für `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows]`_`f und `F33f`_`[macOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MacOS]`_`f frei.`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] Das Release JavaFX 1.0 erschien zusammen mit der Programmiersprache `*JavaFX Script`*. Diese Sprache machte es einfach möglich, hierarchische Objektgraphen aufzubauen und bot eine gute `F33f`_`[Syntax`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntax]`_`f für Object-Binding, womit Zustände synchronisiert werden konnten.`:cite-ref-inselbuch1011-2-2[`F5bf`_`[2`#cite-note-inselbuch1011-2]`_`f]
Die Version 1.2 wurde im Juni 2009 veröffentlicht. Sie enthielt unter anderem anpassbare UI-Controls, zusätzliche Layout-Klassen (Tile, Stack, Flow, ClipView, Panel), Unterstützung für RSS/Atom-Feeds. Sie ist nicht abwärtskompatibel. Erst seit dieser Version wurden `F33f`_`[Linux`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linux]`_`f und `F33f`_`[Solaris`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Solaris_(Betriebssystem)]`_`f unterstützt. Die Version 1.3 (Codename SoMa) wurde am 22. April 2010 veröffentlicht. Die offensichtlichste Neuerung ist eine teils enorme Steigerung der Performance. Neu ist zudem JavaFX TV, eine offizielle CSS-API zur Gestaltung von JavaFX-Controls, einige neue, gewünschte Controls sowie eine Unterstützung von 3D.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f] Die Version 1.3.1 wurde am 21. August 2010 veröffentlicht und verbesserte die Fortschrittsanzeige beim Aufstarten und das Debugging in `F33f`_`[Netbeans`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Netbeans]`_`f 6.9.1.
>>>Version 2
JavaFX 2.0 erschien wie angekündigt im dritten Quartal 2011.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f] In dieser Version wird auf JavaFX Script verzichtet, „denn Oracle wollte keine weitere Programmiersprache aufbauen, sondern eine pure Java-API, die Entwickler dann von unterschiedlichen existierenden Skriptsprachen ansprechen konnten.“`:cite-ref-inselbuch1011-2-3[`F5bf`_`[2`#cite-note-inselbuch1011-2]`_`f] Deshalb wurden die bestehenden JavaFX Script APIs auf Java portiert. In JavaFX 2.0 wurde außerdem das Hardware-Rendering optimiert, sodass nun Spiele und aufwendige 3D-Darstellungen möglich sein sollen. HTML- und JavaScript-Inhalte rendert JavaFX 2.0 mit Hilfe der `F33f`_`[WebKit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=WebKit]`_`f-Bibliothek. Oracle hat im Zuge der Veröffentlichung der neuen Version angekündigt, JavaFX zukünftig als Open-Source-Projekt im Rahmen des `F33f`_`[OpenJDK`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenJDK]`_`f weiterzuentwickeln.`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f]
JavaFX entwickelte sich nun immer mehr zur Alternative von Swing/AWT. Im August 2012 erschien JavaFX 2.2. Dieses wurde in das `F33f`_`[JRE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java-Laufzeitumgebung]`_`f/`F33f`_`[JDK`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Development_Kit]`_`f 7 Update 6 integriert. Der Schritt war ungewöhnlich, denn so große Ergänzungen waren bisher als Update im JRE/JDK noch nie gemacht worden.`:cite-ref-inselbuch1012-9-0[`F5bf`_`[9`#cite-note-inselbuch1012-9]`_`f]
Die Entwicklung in Richtung `F33f`_`[Open Source`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open_Source]`_`f mündete in OpenJFX, wodurch sich zusammen mit dem `F33f`_`[OpenJDK`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenJDK]`_`f ein komplett freies Java-System mit GUI-Stack unter der `F33f`_`[GPL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_General_Public_License]`_`f bauen lässt.`:cite-ref-inselbuch1012-9-1[`F5bf`_`[9`#cite-note-inselbuch1012-9]`_`f]
>>>Version 8
Mit dem Einzug in den Java-8-Release machte dann auch JavaFX den Release-Sprung von 2 auf nun 8. JavaFX 8 bringt einige Neuerungen mit. So bietet es beispielsweise `F33f`_`[Lambdas`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lambda-Funktion]`_`f als neues Sprachkonstrukt an. Eine der großen Neuerungen ist auch das JavaFX-UI-Toolkit, das mit Java 8 als empfohlenes UI-Toolkit ausgeliefert wird. Das Toolkit bietet mit FXML u. a. eine `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensible_Markup_Language]`_`f-basierte Sprache zum Erstellen von Benutzerschnittstellen an.`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f]
Mit der Version 8u33 wurde der `F33f`_`[ARM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ARM-Architektur]`_`f-Support von Oracle für JavaFX eingestellt. Daher ist JavaFX nicht mehr in den offiziellen Java Distributionen für ARM enthalten.`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f]
>>>Roadmap
Oracle plant, die Entwicklung weiterhin zu leiten und mit interessierten Dritten zusammenzuarbeiten.`:cite-ref-12[`F5bf`_`[12`#cite-note-12]`_`f]
>>Architektur
Die Architektur von JavaFX ist von Grund auf neu und beruht insbesondere nicht auf Swing beziehungsweise AWT. Das bedeutet allerdings auch, dass man JavaFX und AWT/Swing nicht ohne Weiteres mischen kann (auch wenn es dafür Lösungen gibt). JavaFX bietet ein komplettes API für moderne Oberflächen an. Die wichtigsten `F33f`_`[Pakete`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Paket_(UML)]`_`f dieser API sind:`:cite-ref-steyer166f-13-0[`F5bf`_`[13`#cite-note-steyer166f-13]`_`f]
`t
| Package | Beschreibung |
|---|---|
| javafx.animation | Klassen für Animationen auf Basis von Übergängen |
| javafx.application | Die Klassen für den grundsätzlichen Lebenszyklus einer Applikation |
| javafx.collections | Essentielle JavaFX-Collections samt Utilities |
| javafx.event | Das Basis-Framework für JavaFX-Events und deren Behandlung |
| javafx.fxml | Klassen zum Laden einer Objekthierarchie aus einer Markup-Struktur wie FXML |
| javafx.geometry | Klassen für geometrische Operationen auf zweidimensionalen Objekten |
| javafx.scene | Die Basisklassen für das JavaFX Scene Graph API und das Elternpaket der einzelnen Komponenten und Elemente. Es enthält Unterpakete wie canvas, chart, control, effect, image, input, layout, media, paint, shape, text, transform, web usw. |
| javafx.stage | Top-Level-Container-Klassen für JavaFX-Inhalte |
| javafx.util | Verschiedene Utilities und Hilfsklassen |
`t
Die folgende Grafik zeigt die Architektur von JavaFX, wie sie von Oracle offiziell dargestellt wird`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f]:
Wie bei jeder Java-Applikation befindet sich auch bei JavaFX auf der untersten Ebene die `F33f`_`[Java Virtual Machine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Virtual_Machine]`_`f (JVM), die für die Ausführung des Java-`F33f`_`[Bytecodes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bytecode]`_`f verantwortlich ist. Hierbei wird im Normalfall jedes gestartete Java-Programm in seiner eigenen `F33f`_`[virtuellen Maschine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Virtuelle_Maschine]`_`f (VM) ausgeführt.
Die entsprechenden `F33f`_`[Entwicklungstools`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Software_Development_Kit]`_`f für Java respektive JavaFX werden im `F33f`_`[Java SE Development Kit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JDK]`_`f (oder nur Java Development Kit, kurz JDK) bereitgestellt. Darauf aufbauend existieren zahlreiche Erweiterungen, die man teils schon sehr lange bei Java nutzen kann, wie beispielsweise `F33f`_`[Java 2D`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_2D]`_`f zum Zeichnen von zweidimensionalen Formen.
Bei Prism`:cite-ref-15[`F5bf`_`[Anmerkung 1`#cite-note-15]`_`f] handelt es sich um die neue `F33f`_`[Rendering Engine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafik-Engine]`_`f, die Gebrauch von der Grafikhardware macht (falls unterstützt). Unter anderem werden damit auch Eigenschaften von Java 2D und diverse grafische Effekte wie Schatten, Spiegelungen, Transformationen oder Animationen auf einer hohen Ebene verfügbar gemacht.`:cite-ref-steyer8f-16-0[`F5bf`_`[15`#cite-note-steyer8f-16]`_`f] Dabei wird unter `F33f`_`[Linux`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linux]`_`f und `F33f`_`[macOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MacOS]`_`f mit `F33f`_`[OpenGL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenGL]`_`f gerendert, während unter `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows]`_`f `F33f`_`[Direct3D`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Direct3D]`_`f zum Einsatz kommt. Wird die Grafikhardware nicht unterstützt, wird ein Software-`F33f`_`[Fallback`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rückfallebene]`_`f auf Java 2D verwendet.`:cite-ref-17[`F5bf`_`[16`#cite-note-17]`_`f]
Das `*Glass Windowing Toolkit`* stellt Low-Level-Betriebssystemroutinen zur Verfügung, wie Fensterverwaltung, Timer oder Ereignisverwaltung. Es dient als plattformabhängige Schicht, die die JavaFX-Plattform mit dem Betriebssystem verbindet.`:cite-ref-steyer8f-16-1[`F5bf`_`[15`#cite-note-steyer8f-16]`_`f]
Die `*Media Engine`* basiert auf `F33f`_`[GStreamer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GStreamer]`_`f und bietet umfangreiche Unterstützung für Audio und Video an. Die `*Web Engine`* ermöglicht die Einbettung von `F33f`_`[Web-Inhalten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=World_Wide_Web]`_`f in JavaFX-Applikationen. Dazu gehört das `F33f`_`[HTML-Rendering`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=HTML-Renderer]`_`f auf Basis der `F33f`_`[WebKit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=WebKit]`_`f-Engine, das hardwareabhängige Rendern über Prism und die Möglichkeit des `F33f`_`[DOM-Zugriffs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Document_Object_Model]`_`f und der Manipulation des DOM.`:cite-ref-steyer8f-16-2[`F5bf`_`[15`#cite-note-steyer8f-16]`_`f]
Das `*Quantum Toolkit`* verknüpft Prism, Glass Windowing Toolkit, Media Engine und Web Engine und macht diese einheitlich den JavaFX-APIs zugänglich. Das JavaFX-API und das Quantum Toolkit kapseln die Details der tieferliegenden Ebenen und verbergen diese vor dem Anwender. Ein JavaFX-Entwickler braucht also im Prinzip gar nicht zu wissen, wie die tieferliegenden Ebenen funktionieren.`:cite-ref-steyer8f-16-3[`F5bf`_`[15`#cite-note-steyer8f-16]`_`f]
>>Aufbau einer JavaFX-Anwendung
>>>JavaFX-Lebenszyklus
JavaFX-Anwendungen erweitern die `F33f`_`[Basisklasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Basisklasse]`_`f `B100`F9d9Application`f`b, die Lebenszyklus-`F33f`_`[Methoden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f wie `B100`F9d9init()`f`b, `B100`F9d9start()`f`b oder `B100`F9d9stop()`f`b `F33f`_`[vererbt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vererbung_(Programmierung)]`_`f. Diese Methoden können (oder müssen) in der JavaFX-Anwendung `F33f`_`[überschrieben`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Überschreiben_(Programmierung)]`_`f werden. Der JavaFX-Launcher kümmert sich darum, dass diese entsprechend aufgerufen werden. JavaFX-Anwendungen benötigen also keine `B100`F9d9main`f`b-Methode: Die eigene statische `B100`F9d9main(String[])`f`b-Methode leitet an die statische `B100`F9d9launch(String[])`f`b-Methode der `B100`F9d9Application`f`b-`F33f`_`[Klasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Klasse_(Objektorientierung)]`_`f weiter und übergibt ihr alle `F33f`_`[Aufrufparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommandozeilenparameter]`_`f.`:cite-ref-18[`F5bf`_`[Anmerkung 2`#cite-note-18]`_`f] Da die Klassenmethode `B100`F9d9launch(...)`f`b weiß, in welcher Klasse sie aufgerufen wurde, erzeugt sie ein Exemplar dieser Klasse und ruft dann die Lebenszyklusmethoden auf.`:cite-ref-ullenboom1032-19-0[`F5bf`_`[17`#cite-note-ullenboom1032-19]`_`f]
Der Lebenszyklus einer JavaFX-Anwendung sieht folgendermaßen aus:`:cite-ref-20[`F5bf`_`[18`#cite-note-20]`_`f]`:cite-ref-epple9f-21-0[`F5bf`_`[19`#cite-note-epple9f-21]`_`f]
1. Beim Start der Anwendung konstruiert die JavaFX-`F33f`_`[Runtime`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Runtime]`_`f zunächst eine `F33f`_`[Instanz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f der `B100`F9d9Application`f`b-Klasse.
2. Nun wird die `B100`F9d9init()`f`b-Methode der erzeugten Instanz ausgeführt. Diese Methode wird als `*default`* leer implementiert und muss nicht zwingend überschrieben werden. Es können hier beispielsweise die Aufrufparameter ausgelesen werden. Es dürfen hier jedoch noch keine UI-Elemente erzeugt werden.`:cite-ref-22[`F5bf`_`[Anmerkung 3`#cite-note-22]`_`f]
3. Als Nächstes wird die Methode `B100`F9d9start(javafx.stage.Stage)`f`b aufgerufen, die von jeder JavaFX-Anwendung überschrieben werden muss. JavaFX übergibt der Methode eine Stage (deutsch „Bühne“), was etwa der Aufgabe eines Haupt-Containers entspricht und am ehesten mit dem Startfenster verglichen werden kann.
4. Die JavaFX-Runtime wartet nun, bis die Anwendung beendet wird. Dies ist folgendermaßen möglich:
• durch Aufruf der Methode `B100`F9d9Platform.exit()`f`b
• indem das letzte Fenster geschlossen wird und das Attribut `B100`F9d9implicitExit`f`b auf Platform auf `B100`F9d9true`f`b gesetzt ist.
5. Nun ruft die Runtime die `B100`F9d9stop()`f`b-Methode auf, bevor der Java-`F33f`_`[Prozess`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozess_(Informatik)]`_`f gestoppt wird. Diese Methode muss wiederum nicht zwingend überschrieben werden.
>>>Die Stage (Bühne)
Der `B100`F9d9start(...)`f`b-Methode wird eine `B100`F9d9Stage`f`b übergeben. Der `F33f`_`[Parameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parameter_(Informatik)]`_`f der `B100`F9d9start(...)`f`b-Methode ist also vom Typ `B100`F9d9javafx.stage.Stage`f`b. Diese Klasse ist der Top-Level-JavaFX-Container, der immer von der Plattform konstruiert wird – als Parameter der `B100`F9d9start(...)`f`b-Methode. Dies kann am ehesten mit dem `F33f`_`[Startfenster`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fenster_(Computer)]`_`f verglichen werden. Zusätzlich können in einer Applikation weitere Stage-`F33f`_`[Objekte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f erstellt werden.`:cite-ref-steyer29-23-0[`F5bf`_`[20`#cite-note-steyer29-23]`_`f]
Die Stage kann verwendet werden, um eine oder mehrere Szenen (engl. `*scenes`*) zu präsentieren. Die Namensgebung der Basisklassen `B100`F9d9Stage`f`b und `B100`F9d9Scene`f`b ist ans Theater angelehnt: Die Stage ist die Bühne, auf der eine Szene aufgeführt wird. Sie bildet den Rahmen für den eigentlichen Inhalt.`:cite-ref-epple11-24-0[`F5bf`_`[21`#cite-note-epple11-24]`_`f]
Für ein Stage-Objekt gibt es wie bei einem Fenster über entsprechende Methoden eine Vielzahl von Einstellungsmöglichkeiten, beispielsweise
• legen `B100`F9d9setWidth(double value)`f`b und `B100`F9d9setHeight(double value)`f`b die Höhe und Breite der Stage fest, und
• `B100`F9d9setTitle(java.lang.String value)`f`b setzt den Titel des Fensters.
Der `B100`F9d9StageStyle`f`b legt das Erscheinungsbild des Fensters fest. Der Standardwert ist `B100`F9d9DECORATED`f`b, der ein Fenster mit vom `F33f`_`[Betriebssystem`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f abhängiger Umrandung und Bedienelementen und weißem Hintergrund anzeigt.`:cite-ref-25[`F5bf`_`[Anmerkung 4`#cite-note-25]`_`f] Die meisten Eigenschaften eines Stage-Objekts können jedoch nur gelesen werden, denn sie werden von der zugrunde liegenden Plattform geändert.`:cite-ref-steyer29-23-1[`F5bf`_`[20`#cite-note-steyer29-23]`_`f]
>>>Die Scene (Szene)
Auf der Stage (Bühne) werden in der Regel eine oder mehrere Szenen präsentiert, die vom Typ `B100`F9d9javafx.scene.Scene`f`b sind. Diese Klasse ist der Container für sämtlichen Inhalt in einem `F33f`_`[Szenengraphen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Szenengraph]`_`f, der die einzelnen Bestandteile einer `F33f`_`[GUI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafische_Benutzeroberfläche]`_`f verwaltet.
Aus `F33f`_`[graphentheoretischer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Graphentheorie]`_`f Sicht ist der Szenengraph ein gewurzelter `F33f`_`[Baum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Baum_(Graphentheorie)]`_`f, der aus Nodes (deutsch `F33f`_`[Knoten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Knoten_(Graphentheorie)]`_`f) besteht. Als `F33f`_`[innere Knoten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Innerer_Knoten]`_`f gibt es Parent-Nodes, die weitere Nodes (Knoten) als Kinder enthalten können. Ein `F33f`_`[Blatt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Blätter_und_innere_Knoten_in_der_Graphentheorie]`_`f (engl. `*leaf node`*) hat dagegen keine weiteren Kinder. Die Blätter stellen nun die sichtbaren Elemente der GUI dar (z. B. Buttons, Textfenster und Slider), die Parent-Nodes die unsichtbaren strukturellen Elemente (z. B. BorderPane, HBox und VBox). Eine Applikation muss den `F33f`_`[Wurzelknoten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wurzel_(Graphentheorie)]`_`f (engl. `*root node`*) für den Szenengraphen angeben. Das ist so etwas wie der Ursprung, aus dem sich die gesamte Szene entwickelt. Dafür gibt es ein Argument für den `F33f`_`[Konstruktor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konstruktoren_und_Destruktoren]`_`f eines `B100`F9d9Scene`f`b-Objekts. Die `B100`F9d9Scene`f`b-Objekte müssen im JavaFX-Application-`F33f`_`[Thread`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f erstellt und modifiziert werden.`:cite-ref-steyer29-65-26-0[`F5bf`_`[22`#cite-note-steyer29-65-26]`_`f]
Die `B100`F9d9Scene`f`b ist auch das Bindeglied zwischen dem Fenster, das vom Betriebssystem zur Verfügung gestellt wird, und dem Szenengraphen. Wird beispielsweise das Fenster vergrößert, versucht die `B100`F9d9Scene`f`b, diese Änderung an den Wurzelknoten weiterzugeben: Sie ruft dazu die Methode `B100`F9d9isResizable`f`b auf dem Root-Node auf, um herauszufinden, ob der Node auf Größenänderungen reagieren möchte. Gibt der Node `B100`F9d9true`f`b zurück, wird die `B100`F9d9Scene`f`b ihn auf die neue Größe verändern, bei `B100`F9d9false`f`b belässt sie ihn.`:cite-ref-epple13-27-0[`F5bf`_`[23`#cite-note-epple13-27]`_`f]`:cite-ref-28[`F5bf`_`[24`#cite-note-28]`_`f]
Mit dem Befehl `B100`F9d9stage.setScene(scene)`f`b kommt der Szenengraph über die Klasse `B100`F9d9Scene`f`b auf die Bühne. Zu jedem Zeitpunkt sind alle grafischen Objekte einer JavaFX-Anwendung präsent, d. h. sie existieren nicht nur zum Zeitpunkt des Zeichnens.`:cite-ref-ullenboom1033-29-0[`F5bf`_`[25`#cite-note-ullenboom1033-29]`_`f]
>>>Nodes (Knoten)
Alle Objekte im Szenengraph sind vom Typ `B100`F9d9Node`f`b. Diese bilden also den Inhalt des Szenengraphen. Jeder Knoten und jedes Element im Szenengraphen ist wiederum ein Untertyp der abstrakten Klasse `B100`F9d9Node`f`b.
Eine Unterklasse von `B100`F9d9Node`f`b ist `B100`F9d9Parent`f`b. Die Parent-Nodes sind die Basisklasse für alle Nodes, die weitere Nodes als Kinder enthalten, also Container sind. Von Parent gibt es wiederum Unterklassen:
• Die Klasse `B100`F9d9Group`f`b fasst mehrere Elemente in einem Knoten zusammen. Sie ermöglicht es beispielsweise, dass Transformationen und Effekte auf die Gruppe angewendet werden und von dieser auf alle Elemente (Kinder) der Gruppe delegiert werden. Der `B100`F9d9Group`f`b-Node führt eine `B100`F9d9ObservableList`f`b von Kindern. Über die Methode `B100`F9d9getChildren()`f`b kann die Liste der Kinder abgerufen werden, der dann über `B100`F9d9getChildren().add(element)`f`b weitere Elemente hinzugefügt werden können. Eine `B100`F9d9Group`f`b kümmert sich nicht um die Positionen der Kinder und kann nicht über CSS angepasst werden.`:cite-ref-30[`F5bf`_`[26`#cite-note-30]`_`f]`:cite-ref-ullenboom1034f-31-0[`F5bf`_`[27`#cite-note-ullenboom1034f-31]`_`f]
• Die Klasse `B100`F9d9Region`f`b bildet die Basisklasse für alle Controls und Layouts und erweitert die Basisklasse um viele Möglichkeiten für das Styling über CSS. Von `B100`F9d9Region`f`b gibt es eine Unterklasse `B100`F9d9Pane`f`b, die die Kinder über öffentliche Methoden nach außen gibt. Die davon abgeleitete Klasse `B100`F9d9BorderPane`f`b positioniert beispielsweise die Kinder oben (`*top`*), links (`*left`*), rechts (`*right`*), unten (`*bottom`*) und in der Mitte (`*center`*).
• Die Klasse `B100`F9d9Control`f`b erweitert die Klasse `B100`F9d9Region`f`b. Sie ist die Basisklasse für Komponenten, die in irgendeiner Form Benutzereingaben erlauben. Dazu gehören beispielsweise Schaltflächen oder Beschriftungen. Jede Control-Komponente lässt sich über CSS wiederum optisch bearbeiten.`:cite-ref-32[`F5bf`_`[28`#cite-note-32]`_`f]`:cite-ref-ullenboom1034f-31-1[`F5bf`_`[27`#cite-note-ullenboom1034f-31]`_`f]
JavaFX kommt – wie Swing – mit einem Satz von Standardkomponenten im Paket `B100`F9d9javafx.scene.control`f`b und hat `B100`F9d9Control`f`b als Basisklasse.`:cite-ref-ullenboom1036-33-0[`F5bf`_`[29`#cite-note-ullenboom1036-33]`_`f] Die folgende Übersicht listet die wichtigsten Controls auf, die in JavaFX zur Verfügung stehen:`:cite-ref-epple43f-34-0[`F5bf`_`[30`#cite-note-epple43f-34]`_`f]`:cite-ref-35[`F5bf`_`[31`#cite-note-35]`_`f]
`t
| Control | Verwendung |
|---|---|
| Label | Das Label ist eines der einfachsten Controls. Es besteht aus einem Text und einem weiteren beliebigen Node zur Deklaration. Häufig wird hierfür ein Image verwendet. |
| Hyperlink | Entspricht einem HTML - Hyperlink und wird standardmäßig als blauer unterstrichener Text dargestellt. |
| Button | Ein Button kann gedrückt werden. Der Selektionszustand bleibt erhalten. |
| RadioButton | Ein Auswahlknopf für die Einzelauswahl aus einer Gruppe von Radiobuttons . Der Selektionszustand bleibt erhalten, bis ein anderer Button derselben Gruppe ausgewählt wird. |
| ToggleButton | Eine Umschaltfläche , die in zwei Zuständen existiert: ausgewählt (selected) und nicht ausgewählt. Verhält sich ähnlich wie eine CheckBox oder ein RadioButton. |
| CheckBox | Ein Checkbox ist ein Auswahlkasten mit drei möglichen Zuständen: undefined, checked und unchecked. Der Selektionszustand bleibt bis zur Änderung erhalten. |
| ChoiceBox | Eine Combobox für die Auswahl eines einzelnen Items aus einer vorzugsweise kurzen Liste. |
| TextField | Einzeiliges Freitexteingabefeld mit Cursorsteuerung und Selektion. |
| TextArea | Mehrzeiliges Freitexteingabefeld mit Cursorsteuerung und Selektion. |
| ListView | Ein (erweitertes) Listenfeld zur Anzeige von Objekten. |
| TableView | Eine Tabellenkomponente , die sich aus einer Reihe von Spalten (TableColumns) zusammensetzt. Einzelne Zellen werden als TableCell repräsentiert. |
| TitledPane | Ein auf- und zuklappbarer Teildialog. |
| ScrollPane | Dient zum Verschieben und Darstellen eines Ausschnittes mit horizontalem und vertikalem ScrollBar ( Rollbalken ). |
`t
Zunächst sind Controls einfach nur Nodes, die dem SceneGraph hinzugefügt werden können, und die dann dargestellt werden. Natürlich stellen die entsprechenden Klassen für UI-Controls diverse spezifische Eigenschaften und Methoden zur Verfügung, um typische Interaktionen mit Anwendern zu unterstützen.
>>>Programmbeispiele
>>>>Hello JavaFX World!
Das folgende Programmbeispiel zeigt ein typisches `F33f`_`[Hallo-Welt-Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hallo-Welt-Programm]`_`f in JavaFX:
`B100`F9d9package application;`f`b
`B100`F9d9`f`b
`B100`F9d9import javafx.application.Application;`f`b
`B100`F9d9import javafx.scene.Scene;`f`b
`B100`F9d9import javafx.scene.control.Label;`f`b
`B100`F9d9import javafx.scene.layout.StackPane;`f`b
`B100`F9d9import javafx.stage.Stage;`f`b
`B100`F9d9`f`b
`B100`F9d9public class Main extends Application {`f`b
`B100`F9d9`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void start(Stage primaryStage) {`f`b
`B100`F9d9 Label label = new Label("Hello JavaFX World!");`f`b
`B100`F9d9`f`b
`B100`F9d9 StackPane root = new StackPane();`f`b
`B100`F9d9 root.getChildren().add(label);`f`b
`B100`F9d9`f`b
`B100`F9d9 Scene scene = new Scene(root, 400, 300);`f`b
`B100`F9d9`f`b
`B100`F9d9 primaryStage.setTitle("Hello JavaFX World!");`f`b
`B100`F9d9 primaryStage.setScene(scene);`f`b
`B100`F9d9 primaryStage.show();`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 public static void main(String[] args) {`f`b
`B100`F9d9 launch(args);`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9}`f`b
Die Klasse `B100`F9d9Main`f`b ist von der Klasse `B100`F9d9Application`f`b abgeleitet. Die eigene `B100`F9d9main(...)`f`b-Methode leitet an die `B100`F9d9launch(...)`f`b-Methode der Application-Klasse weiter. In der erzeugten Instanz der `B100`F9d9Application`f`b-Klasse wird zunächst die `B100`F9d9init()`f`b-Methode ausgeführt, die hier als `*default`* leer implementiert bleibt.
Als Nächstes wird die `B100`F9d9start(...)`f`b-Methode ausgeführt, die wie hier von jeder JavaFX-Anwendung überschrieben werden muss. JavaFX übergibt der Methode eine `B100`F9d9Stage`f`b, die mit dem Startfenster verglichen werden kann. Innerhalb der `B100`F9d9start()`f`b-Methode werden nun die folgenden Schritte ausgeführt:
• Es wird ein einfaches Label-Control `B100`F9d9label`f`b kreiert. Der darzustellende Text „Hello JavaFX World!“ wird hier direkt dem Konstruktor übergeben.
• Nun wird ein `B100`F9d9StackPane`f`b namens `B100`F9d9root`f`b erzeugt. Dieses platziert alle Kindelemente in der Reihenfolge ihres Hinzufügens übereinander. Standardmäßig werden die Komponenten in der StackPane zentriert. Über `B100`F9d9root.getChildren().add(label)`f`b wird nun das zuvor erzeugte `B100`F9d9Label label`f`b hinzugefügt.
• Nun wird eine `B100`F9d9Scene scene`f`b erstellt, die sich anschließend auf die `B100`F9d9Stage`f`b laden lässt. Die Anwendung muss einen Root-Node (Wurzel-Knoten) für den Szenengraph spezifizieren. In diesem Beispiel ist dies das `B100`F9d9root`f`b-Objekt vom Typ `B100`F9d9StackPane`f`b. Außerdem wird hier dem Konstruktor noch eine spezifische Darstellungsgröße ( 400 × × 300 {\\displaystyle 400\\times 300} ) mitgegeben.
• Im nächsten Schritt wird über `B100`F9d9primaryStage.setTitle("Hello JavaFX World!")`f`b der Titel des Anwendungsfensters ebenfalls auf „Hello JavaFX World!“ gesetzt. Am wichtigsten ist aber die Zuweisung der Szene `B100`F9d9scene`f`b, die auf den eigentlichen Inhalt verweist. Die `B100`F9d9show()`f`b-Methode versucht nun das Fenster anzuzeigen, indem die Sichtbarkeit auf `B100`F9d9true`f`b gesetzt wird.
>>>>Cycle of Life
`B100`F9d9package application;`f`b
`B100`F9d9`f`b
`B100`F9d9import javafx.application.Application;`f`b
`B100`F9d9import javafx.application.Platform;`f`b
`B100`F9d9import javafx.stage.Stage;`f`b
`B100`F9d9`f`b
`B100`F9d9public class CycleOfLife extends Application {`f`b
`B100`F9d9`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void init() {`f`b
`B100`F9d9 System.out.printf("Die Methode init(), aufgerufen im Thread %s%n",`f`b
`B100`F9d9 Thread.currentThread());`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void start(Stage primaryStage) {`f`b
`B100`F9d9 System.out.printf("Die Methode start(), aufgerufen im Thread %s%n",`f`b
`B100`F9d9 Thread.currentThread());`f`b
`B100`F9d9 Platform.exit();`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void stop() {`f`b
`B100`F9d9 System.out.printf("Die Methode stop(), aufgerufen im Thread %s%n",`f`b
`B100`F9d9 Thread.currentThread());`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 public static void main(String[] args) {`f`b
`B100`F9d9 System.out.printf("Die Methode main(), aufgerufen im Thread %s%n",`f`b
`B100`F9d9 Thread.currentThread());`f`b
`B100`F9d9 launch(args);`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9}`f`b
Das Programm liefert in etwa den folgenden Output:
Die Methode main(), aufgerufen im Thread Thread[main,5,main]
Die Methode init(), aufgerufen im Thread Thread[JavaFX-Launcher,5,main]
Die Methode start(), aufgerufen im Thread Thread[JavaFX Application Thread,5,main]
Die Methode stop(), aufgerufen im Thread Thread[JavaFX Application Thread,5,main]
Die `B100`F9d9main(...)`f`b-Methode von `B100`F9d9CycleOfLife`f`b ruft `B100`F9d9Application.launch(...)`f`b auf und eine Instanz der `B100`F9d9Application`f`b-Unterklasse wird im `*JavaFX Application `F33f`_`[Thread`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f`* erzeugt. Die `B100`F9d9init()`f`b-Methode wird im `*JavaFX Launcher Thread`* aufgerufen, bei welchem es sich um den Thread handelt, der die Applikation startet. Um die `B100`F9d9start()`f`b- und `B100`F9d9stop()`f`b-Methoden auszuführen, erzeugt JavaFX einen Thread namens `*JavaFX Application Thread`*. Die Erzeugung von `B100`F9d9Stage`f`b- und `B100`F9d9Scene`f`b-Objekten und Modifikationen am Szenengraphen müssen innerhalb dieses `*JavaFX Application Thread`* erfolgen.`:cite-ref-36[`F5bf`_`[32`#cite-note-36]`_`f]
>>Ereignisbehandlung
Das Eventhandling von JavaFX ist die konsequente Weiterentwicklung der `F33f`_`[Ereignisbehandlung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ereignis_(Programmierung)]`_`f unter dem AWT und Swing beziehungsweise Java selbst, aber auch dem Web.`:cite-ref-steyer201-37-0[`F5bf`_`[33`#cite-note-steyer201-37]`_`f] Moderne grafische Programme sind sehr stark ereignisorientiert.`:cite-ref-38[`F5bf`_`[Anmerkung 5`#cite-note-38]`_`f] Man benötigt deshalb Mechanismen, die auf das Auftreten von Ereignissen reagieren.
Ralph Steyer erklärt die Grundidee der Ereignisbehandlung folgendermaßen:
Ein Objekt kann ein Ereignisobjekt abfeuern und ein anderes Objekt registriert sich für eine Reaktion darauf (ein sogenannter Event-Listener), wie etwa beim Funken, bei dem ein Sender mit seinem Funkgerät auf einer bestimmten Frequenz eine Nachricht schickt und ein Empfänger, der sein Funkgerät auf diese Frequenz eingestellt hat, die Nachricht empfängt. Vollkommen analog kann der Empfänger auf eine Mitteilung über ein Ereignis reagieren, oder die Nachricht ignorieren. Im Zuhörerobjekt wird also über die konkrete Ereignisbehandlung entschieden.`:cite-ref-steyer201-37-1[`F5bf`_`[33`#cite-note-steyer201-37]`_`f]
>>>JavaFX-Events
Das Paket `B100`F9d9javafx.event`f`b enthält die relevanten Klassen und Schnittstellen zur Ereignisbehandlung in JavaFX. Grundsätzlich ist ein konkretes Ereignis eine Instanz der Klasse `B100`F9d9javafx.event.Event`f`b beziehungsweise einer ihrer Unterklassen wie `B100`F9d9DragEvent`f`b, `B100`F9d9KeyEvent`f`b, `B100`F9d9MouseEvent`f`b oder `B100`F9d9ScrollEvent`f`b.`:cite-ref-steyer201-37-2[`F5bf`_`[33`#cite-note-steyer201-37]`_`f]
Wenn ein Ereignis auftritt, kommt ein interner Mechanismus zum Einsatz, der bestimmt, welcher Node (Knoten) das Ziel eines Ereignisobjektes ist. Für Mausereignisse ist beispielsweise das Ziel der Node am Ort des Mauszeigers. Von dem selektierten Ereignisziel gibt es eine Ereignisversandkette (engl. `*event dispatch chain`*), die bis zur Wurzel des Szenengraphen hochgeht.
Zuerst wird immer versucht, das Ereignis im innersten Element, bei dem es aufgetreten ist, zu behandeln. Dies erfordert einen geeigneten Eventhandler (oder eine andere Behandlungsstruktur). Hiernach wird das Element des Ereignisobjekts an das nächsthöhere Objekt im Baum weitergeleitet usw. Man spricht in diesem Zusammenhang von Event-Bubbling, da das Ereignisobjekt wie eine Blase (engl. `*bubble`*) bis zur Wurzel des Szenengraphen aufsteigt. Wenn dieses bis zur Wurzel nicht behandelt werden kann, wird es vernichtet. Dies ist durchaus der Regelfall, da viele Ereignisse wie beispielsweise das Verschieben des Mauszeigers um wenige Millimeter keine konkrete Reaktion der Applikation erzwingen.`:cite-ref-steyer202-205-39-0[`F5bf`_`[34`#cite-note-steyer202-205-39]`_`f]
>>>Eventhandler
Wenn irgendein Node in der Route des Eventobjekts einen Eventhandler registriert hat, wird das Ereignis konsumiert. Die Aufgabe des Programmierers besteht also darin, das Ereignis entsprechend aufzufangen und die Reaktion auf dieses zu implementieren. Grundsätzlich implementieren Eventhandler die `B100`F9d9EventHandler`f`b-Schnittstelle, die das Überschreiben einer dort beschriebenen `B100`F9d9handle()`f`b-Methode erzwingt. Dort gehört dann die eigentliche Reaktion auf das aufgetretene Ereignis hin. Diese Methode enthält dann als Parameter ein Ereignisobjekt vom jeweils relevanten Typ.`:cite-ref-steyer205-209-40-0[`F5bf`_`[35`#cite-note-steyer205-209-40]`_`f]
Eine allgemeine Möglichkeit, um einem Node-Objekt einen Eventhandler hinzuzufügen bzw. abzumelden bieten die folgenden beiden Methoden`:cite-ref-ullenboom1037-41-0[`F5bf`_`[36`#cite-note-ullenboom1037-41]`_`f]:
• `B100`F9d9addEventHandler(EventType<T>, EventHandler<? super T>)`f`b zum Hinzufügen eines Handlers
• `B100`F9d9removeEventHandler(EventType<T>, EventHandler<? super T>)`f`b zum Abmelden eines Handlers.
Im ersten Parameter wird jeweils das konkrete Ereignis, auf das man reagieren will, spezifiziert, und im zweiten Parameter der Eventhandler selbst.
Oft wird der Eventhandler als `F33f`_`[anonyme Klasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anonyme_Klasse]`_`f erstellt und registriert und dabei die `B100`F9d9handle()`f`b-Methode direkt implementiert, um die gewünschten Aktionen bereitzustellen. Für einen `B100`F9d9Button`f`b `B100`F9d9btn`f`b könnte das in etwa folgendermaßen aussehen:`:cite-ref-ullenboom1037-41-1[`F5bf`_`[36`#cite-note-ullenboom1037-41]`_`f]
`B100`F9d9btn.addEventHandler(ActionEvent.ACTION, new EventHandler<ActionEvent>() {`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void handle(ActionEvent event) {`f`b
`B100`F9d9 // do something here`f`b
`B100`F9d9 }`f`b
`B100`F9d9});`f`b
Als `F33f`_`[Lambda-Ausdruck`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anonyme_Funktion]`_`f kann dies in etwa folgendermaßen aussehen:
`B100`F9d9btn.addEventHandler(ActionEvent.ACTION, (event) -> {`f`b
`B100`F9d9 // do something here`f`b
`B100`F9d9});`f`b
Darüber hinaus bieten die Komponentenklassen auch eigene Setter-Methoden für spezifische Ereignisse an, die das folgende Format aufweisen:
`B100`F9d9setOnEventType(EventHandler handler)`f`b
Dabei gibt `B100`F9d9EventType`f`b den Typ des Ereignisses an. So gibt es beispielsweise für den `B100`F9d9Button`f`b die Methode `B100`F9d9setOnAction(EventHandler<ActionEvent>)`f`b:
`B100`F9d9btn.setOnAction(new EventHandler<ActionEvent>() {`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void handle(ActionEvent event) {`f`b
`B100`F9d9 // do something here`f`b
`B100`F9d9 }`f`b
`B100`F9d9});`f`b
>>>Dynamische Datenstrukturen mit Änderungsmeldungen
In JavaFX sind nicht nur einzelne Werte observierbar, sondern auch `F33f`_`[dynamische Datenstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamische_Datenstruktur]`_`f, die sich im Paket `B100`F9d9javafx.collections`f`b befinden: `B100`F9d9ObservableList`f`b, `B100`F9d9ObservableMap`f`b und `B100`F9d9ObservableSet`f`b leiten sich jeweils vom `*Observable Interface`* ab und fügen jeweils Methoden hinzu, um die passenden `B100`F9d9ChangeListener`f`b zu registrieren. Die neuen Datenstrukturen erweitern also die `B100`F9d9java.util`f`b-Datenstrukturen `B100`F9d9List`f`b, `B100`F9d9Set`f`b und `B100`F9d9Map`f`b und können Veränderungen melden.
Zu einer `B100`F9d9ObservableList`f`b existiert beispielsweise die Schnittstelle `B100`F9d9ListChangeListener`f`b, die auf Änderungen der observierten Liste reagiert. Die Klasse `B100`F9d9ListChangeListener.Change`f`b repräsentiert eine Änderung, die an einer solchen Liste vollzogen wird. Mit
`B100`F9d9observableList.addListener(new ListChangeListener(){/* do something here */});`f`b
wird dann der Listener für Veränderungen der Liste registriert.`:cite-ref-steyer193ff-42-0[`F5bf`_`[37`#cite-note-steyer193ff-42]`_`f]`:cite-ref-ullenboom379-388-43-0[`F5bf`_`[38`#cite-note-ullenboom379-388-43]`_`f]`:cite-ref-epple22f-44-0[`F5bf`_`[39`#cite-note-epple22f-44]`_`f]
>>>Properties und Data Binding
Properties und Data Binding sind zwei mächtige Sprach-Mechanismen in JavaFX, mit denen Beziehungen zwischen Variablen gestaltet werden können. Meist werden sie zur (gegenseitigen) Aktualisierung von Werten herangezogen. Der Benutzer bedient zum Beispiel einen Schieberegler, der die Breite eines Rechtecks regelt, und in Abhängigkeit vom eingestellten Wert muss der `B100`F9d9width`f`b-Wert des Datenmodells aktualisiert werden und die Fläche des Rechtecks neu berechnet werden. Um die Daten miteinander abzugleichen, gibt es deshalb das Konzept von Properties und Data Binding.
Properties sind in JavaFX die Grundbausteine für die Verarbeitung und Kommunikation von Wertänderungen. Sie bilden die Basis für ein komfortables Data Binding. Ein Property ist ein Datencontainer, der zusätzlich Änderungsbenachrichtigungen ermöglicht. An Änderungen interessierte andere Klassen können sich als Listener registrieren. Man spricht bei einer Bindung auch von Abhängigkeiten beziehungsweise `*dependency`*.`:cite-ref-steyer225-45-0[`F5bf`_`[40`#cite-note-steyer225-45]`_`f]
Die Binding-APIs werden in JavaFX in zwei Kategorien unterteilt:`:cite-ref-steyer225-45-1[`F5bf`_`[40`#cite-note-steyer225-45]`_`f]`:cite-ref-oracle-binding-46-0[`F5bf`_`[41`#cite-note-oracle-binding-46]`_`f]
• Das High-Level-API: Bietet für die meisten Situationen einen einfachen Weg zur Erstellung von Bindungen. Insbesondere wird hierfür in IDEs wie NetBeans eine Codevervollständigung bereitgestellt.
• Das Low-Level-API: Dieses API ist sehr flexibel, schlank und schnell und bietet erweiterte Möglichkeiten, wenn das High-Level-API nicht ausreicht.
Im Package `B100`F9d9javafx.beans.property`f`b sind verschiedene Property-Klassen definiert, etwa zur Kapselung von `B100`F9d9int`f`b, `B100`F9d9long`f`b, `B100`F9d9float`f`b, `B100`F9d9double`f`b, `B100`F9d9boolean`f`b und `B100`F9d9String`f`b. Zur Änderungsbenachrichtigung implementieren die Properties das Interface `B100`F9d9Observable`f`b bzw. `B100`F9d9ObservableValue<T>`f`b. So wird zum Beispiel anstatt des `F33f`_`[primitiven Datentyps`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Primitiver_Datentyp]`_`f `F33f`_`[double`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Doppelte_Genauigkeit]`_`f ein neuer Typ `B100`F9d9DoubleProperty`f`b verwendet, der den primitiven Typ `B100`F9d9double`f`b „einwickelt“. Bei den JavaFX-Properties gibt es neben den `F33f`_`[Getter- und Setter-Methoden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zugriffsfunktion]`_`f noch eine zusätzliche Methode, die mit `*Property`* endet und das Property-Objekt zurückliefert.
Das folgende Beispiel stammt aus den Java-Dokumentationen von Oracle und definiert eine Klasse namens `B100`F9d9Bill`f`b (deutsch `*Rechnung`*), die eine einzige Property namens `B100`F9d9amountDue`f`b (deutsch `*fälliger Betrag`*) implementiert:`:cite-ref-oracle-binding-46-1[`F5bf`_`[41`#cite-note-oracle-binding-46]`_`f]
`B100`F9d9package application;`f`b
`B100`F9d9`f`b
`B100`F9d9import javafx.beans.property.DoubleProperty;`f`b
`B100`F9d9import javafx.beans.property.SimpleDoubleProperty;`f`b
`B100`F9d9`f`b
`B100`F9d9public class Bill {`f`b
`B100`F9d9`f`b
`B100`F9d9 // Definiere eine Variable um die Property zu speichern`f`b
`B100`F9d9 private DoubleProperty amountDue = new SimpleDoubleProperty();`f`b
`B100`F9d9`f`b
`B100`F9d9 // Definiere die Getter-Methode für den Wert der Property`f`b
`B100`F9d9 public final double getAmountDue() {`f`b
`B100`F9d9 return amountDue.get();`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 // Definiere die Setter-Methode für den Wert der Property`f`b
`B100`F9d9 public final void setAmountDue(double value) {`f`b
`B100`F9d9 amountDue.set(value);`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 // Definiere einen Getter für die Property selbst`f`b
`B100`F9d9 public DoubleProperty amountDueProperty() {`f`b
`B100`F9d9 return amountDue;`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9}`f`b
Das `B100`F9d9amountDue`f`b-Objekt ist eine Instanz der Klasse `B100`F9d9javafx.beans.property.DoubleProperty`f`b. Um sie zu kapseln, ist sie als `B100`F9d9private`f`b markiert. Entsprechend der Namenskonvention für den Zugriff auf Properties gibt es die folgenden Methoden:
• Die `B100`F9d9getAmountDue()`f`b-Methode ist der standardmäßige Getter, der den aktuellen Wert der `B100`F9d9amountDue`f`b-Property zurückgibt. Der Rückgabewert dieser Methode ist `B100`F9d9double`f`b (und nicht etwa `B100`F9d9DoubleProperty`f`b). Die Getter-Methode sollte als `B100`F9d9final`f`b deklariert werden.
• Die `B100`F9d9setAmountDue(double)`f`b-Methode ist ebenfalls als `B100`F9d9final`f`b deklariert und ermöglicht es, von außen den Wert der Property zu setzen. Ihr Parameter ist ebenfalls `B100`F9d9double`f`b.
• Die `B100`F9d9amountDueProperty()`f`b-Methode definiert den Getter der Property und gibt die Property selbst zurück. Sie ist eine neue Konvention, die sich aus dem Namen der Property (hier `*amountDue`*) und dem Wort `*Property`* zusammensetzt.
Properties sind insbesondere dann von Interesse, wenn man deren Veränderungen beobachtet. Im Ereignismodell von Java gibt es sogenannte Ereignisauslöser (Ereignisquellen, engl. `*event sources`*), wie zum Beispiel Schaltflächen oder Schieberegler. Diese Ereignisse können von Benutzern der grafischen Oberfläche stammen, aber auch auf eigene Auslöser zurückzuführen sein. Neben den Ereignisauslösern gibt es eine Reihe von Interessenten, sogenannte Listener, die informiert werden wollen, wenn ein bestimmtes Ereignis auftritt.`:cite-ref-ullenboom806f-47-0[`F5bf`_`[42`#cite-note-ullenboom806f-47]`_`f] Zu den Properties existiert für diesen Fall ein `B100`F9d9ChangeListener`f`b (`B100`F9d9javafx.beans.value.ChangeListener`f`b), der über die Methode `B100`F9d9addListener()`f`b an die Property angehängt werden kann, die mit der entsprechenden Getter-Methode zurückgegeben wird.`:cite-ref-steyer228-231-48-0[`F5bf`_`[43`#cite-note-steyer228-231-48]`_`f]
Zur Veranschaulichung eines ChangeListeners wird in den Java-Dokumentationen in der `B100`F9d9Main`f`b-Klasse eine Instanz `B100`F9d9electricalBill`f`b der Klasse `B100`F9d9Bill`f`b (siehe oben) erstellt:`:cite-ref-oracle-binding-46-2[`F5bf`_`[41`#cite-note-oracle-binding-46]`_`f]
`B100`F9d9package application;`f`b
`B100`F9d9`f`b
`B100`F9d9import javafx.beans.value.ObservableValue;`f`b
`B100`F9d9import javafx.beans.value.ChangeListener;`f`b
`B100`F9d9`f`b
`B100`F9d9public class Main {`f`b
`B100`F9d9`f`b
`B100`F9d9 public static void main(String[] args) {`f`b
`B100`F9d9 Bill electricBill = new Bill();`f`b
`B100`F9d9`f`b
`B100`F9d9 electricBill.amountDueProperty().addListener(new ChangeListener<Object>(){`f`b
`B100`F9d9 @Override`f`b
`B100`F9d9 public void changed(ObservableValue<?> o,Object oldVal, Object newVal) {`f`b
`B100`F9d9 System.out.println("Electric bill has changed!");`f`b
`B100`F9d9 }`f`b
`B100`F9d9 });`f`b
`B100`F9d9`f`b
`B100`F9d9 electricBill.setAmountDue(100.00);`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9}`f`b
Als Ausgabe erscheint in der Konsole `*Electric bill has changed!`* Der Listener hat also bemerkt, dass mit `B100`F9d9electricBill.setAmountDue(100.00)`f`b der Wert der amountDue-Property geändert und die entsprechende Nachricht über die `B100`F9d9changed(...)`f`b-Methode ausgegeben wurde.
Die High-Level-APIs sind der einfachste und schnellste Weg, um Bindings einzusetzen. Sie bestehen aus zwei Teilen: dem Fluent-API und der Binding-Klasse. Das Fluent-API stellt zahlreiche Methoden auf abhängigen Objekten bereit, während die Binding-Klasse statische Factory-Methoden anbietet.
Im folgenden Beispiel werden zwei `F33f`_`[Integers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integer_(Datentyp)]`_`f so gebunden, dass ihre Werte immer automatisch in der `F33f`_`[Summe`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Summe]`_`f `B100`F9d9sum`f`b addiert werden:`:cite-ref-oracle-binding-46-3[`F5bf`_`[41`#cite-note-oracle-binding-46]`_`f]
`B100`F9d9package application;`f`b
`B100`F9d9`f`b
`B100`F9d9import javafx.beans.property.IntegerProperty;`f`b
`B100`F9d9import javafx.beans.property.SimpleIntegerProperty;`f`b
`B100`F9d9import javafx.beans.binding.NumberBinding;`f`b
`B100`F9d9`f`b
`B100`F9d9public class Main {`f`b
`B100`F9d9`f`b
`B100`F9d9 public static void main(String[] args) {`f`b
`B100`F9d9 IntegerProperty num1 = new SimpleIntegerProperty(1);`f`b
`B100`F9d9 IntegerProperty num2 = new SimpleIntegerProperty(2);`f`b
`B100`F9d9`f`b
`B100`F9d9 NumberBinding sum = num1.add(num2);`f`b
`B100`F9d9`f`b
`B100`F9d9 System.out.println(sum.getValue());`f`b
`B100`F9d9`f`b
`B100`F9d9 num1.set(2);`f`b
`B100`F9d9`f`b
`B100`F9d9 System.out.println(sum.getValue());`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9}`f`b
Es gibt insgesamt drei Variablen, nämlich die beiden abhängigen Variablen `B100`F9d9num1`f`b und `B100`F9d9num2`f`b und die Bindung `B100`F9d9sum`f`b. Die abhängigen Variablen sind beide vom Typ `B100`F9d9IntegerProperty`f`b und die Bindung selbst ist vom Typ `B100`F9d9NumberBinding`f`b. Der Wert von `B100`F9d9sum`f`b ändert sich also automatisch, wenn sich `B100`F9d9num1`f`b oder `B100`F9d9num2`f`b ändern.
>>Deklarative GUI-Beschreibungen
Grundsätzlich können grafische Oberflächen über eine Programm-API aufgebaut werden, oder aber in einer `F33f`_`[deklarativen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deklarative_Programmierung]`_`f Beschreibung spezifiziert werden. Bei deklarativen Oberflächen wird die Anordnung der Komponenten in einer externen Ressourcendatei beschrieben.
>>>FXML
Neben der Möglichkeit, den Szenengraphen über den Programmcode aufzubauen, bietet JavaFX auch die Möglichkeit, die Objekte über `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensible_Markup_Language]`_`f zu konfigurieren. Mit FXML stellt JavaFX eine einfach zu erlernende, deklarative Sprache zur Verfügung, die eine alternative Definition von grafischen Oberflächen rein über XML erlaubt.`:cite-ref-49[`F5bf`_`[Anmerkung 6`#cite-note-49]`_`f] Da XML hierarchisch strukturiert ist, kann die grundlegende hierarchische Gliederung einer GUI in Containern und Komponenten sehr gut auf XML-Basis abgebildet werden. Dies macht es auch einfacher, das Layout sauber vom Code zu trennen. Darüber hinaus können dort Web-Technologien wie `F33f`_`[CSS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cascading_Style_Sheets]`_`f (Cascading Style Sheets), `F33f`_`[JavaScript`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JavaScript]`_`f aber auch andere Sprachen wie `F33f`_`[Groovy`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Groovy]`_`f eingesetzt werden, indem sie in den XML-Code eingebettet und damit verknüpft werden.`:cite-ref-steyer9f-50-0[`F5bf`_`[44`#cite-note-steyer9f-50]`_`f]`:cite-ref-ullenboom1062f-51-0[`F5bf`_`[45`#cite-note-ullenboom1062f-51]`_`f]`:cite-ref-inselbuch1013f-52-0[`F5bf`_`[46`#cite-note-inselbuch1013f-52]`_`f]
Zum Laden einer FXML-Ressource kommt die Klasse `B100`F9d9javafx.fxml.FXMLLoader`f`b und dessen Klassenmethode `B100`F9d9load(...)`f`b zum Einsatz. Hier muss der relative Pfad zur `B100`F9d9*.fxml`f`b-Datei als Parameter übergeben werden. Nun kann die angegebene Datei als Ressource geladen und daraus ein Objekt vom Typ `B100`F9d9javafx.scene.Parent`f`b erzeugt werden. Dieses wird dem Konstruktor des Scene-Objekts als Parameter übergeben.`:cite-ref-steyer65f-53-0[`F5bf`_`[47`#cite-note-steyer65f-53]`_`f]
In den Java-Dokumentationen wird der Unterschied zwischen Code und FXML am folgenden einfachen Beispiel veranschaulicht:`:cite-ref-54[`F5bf`_`[48`#cite-note-54]`_`f]
Der folgende Programmcode baut eine grafische Oberfläche auf, die aus einem `B100`F9d9BorderPane`f`b besteht, das oben das `B100`F9d9Label`f`b mit der Beschriftung `*Page Title`* enthält und im Zentrum ein `B100`F9d9Label`f`b mit der Beschriftung `*Some data here`*:
`B100`F9d9BorderPane border = new BorderPane();`f`b
`B100`F9d9Label toppanetext = new Label("Page Title");`f`b
`B100`F9d9border.setTop(toppanetext);`f`b
`B100`F9d9Label centerpanetext = new Label ("Some data here");`f`b
`B100`F9d9border.setCenter(centerpanetext);`f`b
Dieselbe Oberfläche wird in FXML folgendermaßen beschrieben:
`B100`F9d9<BorderPane>`f`b
`B100`F9d9 <top>`f`b
`B100`F9d9 <Label text="Page Title"/>`f`b
`B100`F9d9 </top>`f`b
`B100`F9d9 <center>`f`b
`B100`F9d9 <Label text="Some data here"/>`f`b
`B100`F9d9 </center>`f`b
`B100`F9d9</BorderPane>`f`b
Die hierarchische Struktur der Oberfläche kann also sehr gut in der hierarchisch strukturierten `F33f`_`[Auszeichnungssprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Auszeichnungssprache]`_`f FXML dargestellt werden. Dies macht es einfacher, Komponenten hinzuzufügen und die Gliederung einer GUI aufzubauen.
>>>Der Scene Builder
Der JavaFX Scene Builder ist ein grafisches Tool, das die Erstellung von FXML-Dateien vereinfacht. Mit dem Tool können GUI-Elemente ohne Programmierkenntnisse entworfen werden. Der Anwender kann per `F33f`_`[Drag and Drop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Drag_and_Drop]`_`f die XML-Strukturen von FXML visuell gestalten und generieren lassen.`:cite-ref-55[`F5bf`_`[Anmerkung 7`#cite-note-55]`_`f]
Oracle hat die Entwicklung des Tools eingestellt und den `F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f des Programms unter einer BSD-ähnlichen Lizenz freigegeben.`:cite-ref-56[`F5bf`_`[49`#cite-note-56]`_`f] Daraufhin hat die Firma Gluon die Wartung und den kommerziellen Support übernommen.`:cite-ref-57[`F5bf`_`[50`#cite-note-57]`_`f]
>>>FXGraph
FXGraph ist eine einfache `F33f`_`[DSL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Domänenspezifische_Sprache]`_`f (`*Domain Specific Language`*) zur Definition des Objektgraphen, der im Hintergrund in FXML umgesetzt wird. FXGraph stammt aus dem Projekt e(fx)clipse, eine JavaFX-Unterstützung in `F33f`_`[Eclipse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eclipse_(IDE)]`_`f.`:cite-ref-58[`F5bf`_`[51`#cite-note-58]`_`f] FXGraph ist kompakter als FXML und erinnert entfernt an `F33f`_`[JSON`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JSON]`_`f.`:cite-ref-inselbuch1014-59-0[`F5bf`_`[52`#cite-note-inselbuch1014-59]`_`f]
>>Kritik
Der ehemalige Sun-Mitarbeiter und Codename-One-Gründer Shai Almog bescheinigt JavaFX eine wenig rosige Zukunft. Er teilt JavaFX-Nutzer in drei Kategorien: Unternehmen mit großen Investitionen in Swing, Studenten und eingefleischte Fans. Auf diesem Fundament lasse sich laut Almog nur schwer eine lebhafte `F33f`_`[Community`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Online-Community]`_`f aufbauen. Außerdem sende Oracle keine klaren Signale aus, wie es um sein zukünftiges Engagement für JavaFX bestellt sei. Insgesamt macht er für die mangelnde Zukunft von JavaFX drei Hauptgründe verantwortlich:
• Oracle selbst nutzt JavaFX nicht bzw. nicht in ausreichendem Maße: Selbst Swing-basierte Produkte bewegen sich nicht in Richtung JavaFX. Zudem wird der Scene Builder seit einiger Zeit nicht mehr von Oracle selbst vertrieben.
• JavaFX hat nie denselben Einfluss wie Swing gewonnen. Die Hauptzielgruppe von JavaFX, nämlich die Swing-Entwickler, seien nicht auf die neue Technologie umgestiegen.
• Der Jobmarkt sehe düster aus: Auf der Karriereseite `*dice.com`* fand Almog nur 28 Stellen, die JavaFX-Kenntnisse verlangten, im Gegensatz zu 198 Stellenangebote für Swing, 2333 für `F33f`_`[Android`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Android_(Betriebssystem)]`_`f und 16752 für Java EE (Stand 22. November 2015).`:cite-ref-almog-60-0[`F5bf`_`[53`#cite-note-almog-60]`_`f]`:cite-ref-61[`F5bf`_`[54`#cite-note-61]`_`f]
Nachdem der Support für die ARM Embedded Platform und die Entwicklung des Scene Builders von Oracle eingestellt wurden, forderte unter anderem der iJUG-Verbund (Interessenverbund deutscher Java User Groups) von Oracle ein explizites Bekenntnis zu JavaFX.`:cite-ref-62[`F5bf`_`[55`#cite-note-62]`_`f] Daraufhin stellte Don Smith (Oracle Senior Director Product Management) klar, dass JavaFX auch weiterhin die empfohlene Technologie für die Entwicklung von Rich Clients sei und diesbezüglich auch weiterentwickelt werde. Der wegfallende Support der ARM-Plattform habe mit dem hohen Aufwand zu tun, angesichts einer sich sehr schnell verändernden Hardware-Technik einen nachhaltigen kommerziellen ARM-Support zu garantieren. Der Scene Builder sei unter der offenen `F33f`_`[BSD-Lizenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=BSD-Lizenz]`_`f verfügbar gemacht worden und die Strategie bestehe nun darin, den Scene Builder in Tools und Entwicklungsplattformen zu integrieren. Smith verweist insbesondere auf das Startup Gluon, das sich mit JavaFX-Ports und dem Scene Builder befasst.`:cite-ref-schlosser-63-0[`F5bf`_`[56`#cite-note-schlosser-63]`_`f]
Insgesamt steht Java in Konkurrenz mit zahlreichen anderen Technologien: Auf der Serverseite beispielsweise mit `F33f`_`[Node.js`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Node.js]`_`f und `F33f`_`[Ruby on Rails`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ruby_on_Rails]`_`f, auf Mobile-Seite mit `F33f`_`[iOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IOS_(Betriebssystem)]`_`f und in den Bereichen Mobile und Desktop mit HTML und JavaScript.`:cite-ref-almog-60-1[`F5bf`_`[53`#cite-note-almog-60]`_`f] Ob sich JavaFX als Technologie für Web-Oberflächen durchsetzen wird, muss die Zeit noch zeigen.
Einige Experten sehen für JavaFX insbesondere eine Nische im Bereich mächtiger Desktop-Clients mit anspruchsvoller grafischer Interaktion, in der es sich dauerhaft etablieren könnte. So sehen sie die Stärken des Frameworks nicht zuletzt bei der Entwicklung hybrider Desktopanwendungen. Auch jeder, der einen Client mit direktem Zugriff auf lokale Ressourcen (Dateisystem, serielle Ressourcen usw.) entwickelt, sei mit JavaFX gut aufgehoben.`:cite-ref-schlosser-63-1[`F5bf`_`[56`#cite-note-schlosser-63]`_`f]`:cite-ref-64[`F5bf`_`[57`#cite-note-64]`_`f]
>>Literatur
• Anton Epple: `*JavaFX 8. Grundlagen und fortgeschrittene Techniken.`* dpunkt.verlag: Heidelberg, 2015.
• Ralph Steyer: `*Einführung in JavaFX. Moderne GUIs für RIAs und Java-Applikationen.`* Springer Vieweg: Wiesbaden, 2014.
• Christian Ullenboom: `*Java ist auch eine Insel. Einführung, Ausbildung, Praxis.`* 11. Auflage. Galileo Press: Bonn, 2014, insb. S. 1009–1063.
• Christian Ullenboom: `*Java SE 8 Standard-Bibliothek. Das Handbuch für Java-Entwickler.`* 2. Auflage. 2014, Galileo Press: Bonn, 2014, insb. S. 1031–1076.
>>Weblinks
• Oracle: Java Platform, Standard Edition (Java SE) 8 `*Java-Dokumentationen von Oracle`*
• Jonathan Giles, Jasper Potts und Richard Bair: fx experience `*Link-Sammlung zu Beiträgen, die JavaFX-Neuerungen beschreiben`*
• Christian Ullenboom, u. a.: Java Blog `*Zahlreiche Beiträge zu Java und JavaFX`*
>>Einzelnachweise
`:cite-note-4a1e7bf7ce4315c6-1`!1.`! 21.0.6 January 21, 2025 release notes. 21. Januar 2025 (abgerufen am 4. Februar 2025).
`:cite-note-inselbuch1011-2`!2.`! `F0af`_`[↑`#cite-ref-inselbuch1011-2-0]`_`f Christian Ullenboom: Java ist auch eine Insel. 11. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2873-2, S. 1011 (1306 Seiten).
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f `*JavaFX Frequently Asked Questions.`* In: `*oracle.com.`* Abgerufen am 29. Februar 2016 (englisch).
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f Donald Smith: `*The Future of JavaFX and Other Java Client Roadmap Updates.`* In: `*blogs.oracle.com.`* 7. März 2018, abgerufen am 17. November 2018 (englisch).
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f Josh Marinacci: `*JavaFX 1.0 is Live.`* In: `*blogs.sun.com.`* 4. Dezember 2008, archiviert vom Original (nicht mehr online verfügbar) am 7. Dezember 2008; abgerufen am 17. April 2018 (englisch).
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f Jacob Lehrbaum: `*JavaFX 1.3 Released.`* In: `*blogs.sun.com.`* 22. April 2010, archiviert vom Original (nicht mehr online verfügbar) am 26. April 2010; abgerufen am 27. Oktober 2022 (englisch).
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `*JavaFX 2010–2011 Roadmap.`* In: `*javafx.com.`* Archiviert vom Original (nicht mehr online verfügbar) am 29. Oktober 2010; abgerufen am 17. April 2018 (englisch).
`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f Markus Franz: `*JavaFX 2.0: Flash-Konkurrent wird Open Source.`* In: `*netzwelt.de.`* 5. Oktober 2011, archiviert vom Original (nicht mehr online verfügbar) am 3. Dezember 2016; abgerufen am 13. Oktober 2011.
`:cite-note-inselbuch1012-9`!9.`! `F0af`_`[↑`#cite-ref-inselbuch1012-9-0]`_`f Christian Ullenboom: Java ist auch eine Insel. 11. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2873-2, S. 1012 (1306 Seiten, eingeschränkte Vorschau in der Google-Buchsuche).
`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f Hendrik Ebbers: `*JavaFX8 – Was ist neu?`* In: `*jaxenter.de.`* 20. März 2014, abgerufen am 12. Dezember 2016.
`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f `*Java Development Kit for ARM Release Notes 8 Update 33.`* In: `*oracle.com.`* 16. Februar 2013, abgerufen am 29. Februar 2016 (englisch): „Starting with JDK 8u33, JavaFX Embedded is removed from the ARM bundle and is not supported.“
`:cite-note-12`!12.`! `F0af`_`[↑`#cite-ref-12]`_`f `*Java Client Roadmap Update.`* (PDF; 264 kB) In: `*oracle.com.`* Oracle Corporation, 11. Mai 2020, abgerufen am 14. Februar 2021 (englisch).
`:cite-note-steyer166f-13`!13.`! `F0af`_`[↑`#cite-ref-steyer166f-13-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 166 f., `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f Cindy Castillo: `*JavaFX Architecture.`* In: `*docs.oracle.com.`* April 2013, abgerufen am 14. Dezember 2016 (englisch).
`:cite-note-steyer8f-16`!15.`! `F0af`_`[↑`#cite-ref-steyer8f-16-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 8 f., `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-17`!16.`! `F0af`_`[↑`#cite-ref-17]`_`f Gerrit Grunwald: Visualisierung in Java mit JavaFX. In: `*`F33f`_`[Heise online`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Heise_online]`_`f.`* 28. Juni 2013. Abgerufen am 14. Dezember 2016.
`:cite-note-ullenboom1032-19`!17.`! `F0af`_`[↑`#cite-ref-ullenboom1032-19-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1032 (1448 Seiten).
`:cite-note-20`!18.`! `F0af`_`[↑`#cite-ref-20]`_`f `*Class Application.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch).
`:cite-note-epple9f-21`!19.`! `F0af`_`[↑`#cite-ref-epple9f-21-0]`_`f Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 9 f. (296 Seiten).
`:cite-note-steyer29-23`!20.`! `F0af`_`[↑`#cite-ref-steyer29-23-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 29, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-epple11-24`!21.`! `F0af`_`[↑`#cite-ref-epple11-24-0]`_`f Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 11 (296 Seiten).
`:cite-note-steyer29-65-26`!22.`! `F0af`_`[↑`#cite-ref-steyer29-65-26-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 29, 65, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-epple13-27`!23.`! `F0af`_`[↑`#cite-ref-epple13-27-0]`_`f Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 13 (296 Seiten).
`:cite-note-28`!24.`! `F0af`_`[↑`#cite-ref-28]`_`f `*Class Scene.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch).
`:cite-note-ullenboom1033-29`!25.`! `F0af`_`[↑`#cite-ref-ullenboom1033-29-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1033 (1448 Seiten).
`:cite-note-30`!26.`! `F0af`_`[↑`#cite-ref-30]`_`f `*Class Group.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch).
`:cite-note-ullenboom1034f-31`!27.`! `F0af`_`[↑`#cite-ref-ullenboom1034f-31-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1034 f. (1448 Seiten).
`:cite-note-32`!28.`! `F0af`_`[↑`#cite-ref-32]`_`f `*Class Control.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch).
`:cite-note-ullenboom1036-33`!29.`! `F0af`_`[↑`#cite-ref-ullenboom1036-33-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1036 (1448 Seiten).
`:cite-note-epple43f-34`!30.`! `F0af`_`[↑`#cite-ref-epple43f-34-0]`_`f Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 43 f. (296 Seiten).
`:cite-note-35`!31.`! `F0af`_`[↑`#cite-ref-35]`_`f `*JavaFX UI Controls.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch).
`:cite-note-36`!32.`! `F0af`_`[↑`#cite-ref-36]`_`f Jeff Friesen: `*Exploring JavaFX’s Application class.`* In: `*infoworld.com.`* 14. April 2016, abgerufen am 13. Dezember 2016 (englisch).
`:cite-note-steyer201-37`!33.`! `F0af`_`[↑`#cite-ref-steyer201-37-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 201, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-steyer202-205-39`!34.`! `F0af`_`[↑`#cite-ref-steyer202-205-39-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 202–205, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-steyer205-209-40`!35.`! `F0af`_`[↑`#cite-ref-steyer205-209-40-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 205–209, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-ullenboom1037-41`!36.`! `F0af`_`[↑`#cite-ref-ullenboom1037-41-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1037 (1448 Seiten).
`:cite-note-steyer193ff-42`!37.`! `F0af`_`[↑`#cite-ref-steyer193ff-42-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 193 ff., `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-ullenboom379-388-43`!38.`! `F0af`_`[↑`#cite-ref-ullenboom379-388-43-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 379–388 (1448 Seiten).
`:cite-note-epple22f-44`!39.`! `F0af`_`[↑`#cite-ref-epple22f-44-0]`_`f Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 22 f. (296 Seiten).
`:cite-note-steyer225-45`!40.`! `F0af`_`[↑`#cite-ref-steyer225-45-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 225, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-oracle-binding-46`!41.`! `F0af`_`[↑`#cite-ref-oracle-binding-46-0]`_`f `*JavaFX: Properties and Binding Tutorial.`* In: `*docs.oracle.com.`* Abgerufen am 13. Dezember 2016 (englisch).
`:cite-note-ullenboom806f-47`!42.`! `F0af`_`[↑`#cite-ref-ullenboom806f-47-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 806 f. (1448 Seiten).
`:cite-note-steyer228-231-48`!43.`! `F0af`_`[↑`#cite-ref-steyer228-231-48-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 228–231, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-steyer9f-50`!44.`! `F0af`_`[↑`#cite-ref-steyer9f-50-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 9 f., `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-ullenboom1062f-51`!45.`! `F0af`_`[↑`#cite-ref-ullenboom1062f-51-0]`_`f Christian Ullenboom: Java SE 8 Standard-Bibliothek. 2. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2874-9, S. 1062 f. (1448 Seiten).
`:cite-note-inselbuch1013f-52`!46.`! `F0af`_`[↑`#cite-ref-inselbuch1013f-52-0]`_`f Christian Ullenboom: Java ist auch eine Insel. 11. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2873-2, S. 1013 f. (1306 Seiten, eingeschränkte Vorschau in der Google-Buchsuche).
`:cite-note-steyer65f-53`!47.`! `F0af`_`[↑`#cite-ref-steyer65f-53-0]`_`f Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 65 f., `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-54`!48.`! `F0af`_`[↑`#cite-ref-54]`_`f Irina Fedortsova: `*Mastering FXML.`* In: `*docs.oracle.com.`* Januar 2014, abgerufen am 14. Dezember 2016 (englisch).
`:cite-note-56`!49.`! `F0af`_`[↑`#cite-ref-56]`_`f Simon Vienot: `*Scene Builder is now open source!`* In: `*mail.openjdk.org.`* 3. Dezember 2013, abgerufen am 29. März 2016 (englisch).
`:cite-note-57`!50.`! `F0af`_`[↑`#cite-ref-57]`_`f `*Gluon supports Scene Builder.`* In: `*gluonhq.com.`* 4. März 2015, abgerufen am 29. März 2016 (englisch).
`:cite-note-58`!51.`! `F0af`_`[↑`#cite-ref-58]`_`f Tom Schindl: `*FXGraph.`* In: `*eclipse.org.`* 9. Dezember 2013, abgerufen am 13. Dezember 2016 (englisch).
`:cite-note-inselbuch1014-59`!52.`! `F0af`_`[↑`#cite-ref-inselbuch1014-59-0]`_`f Christian Ullenboom: Java ist auch eine Insel. 11. Auflage. Galileo Press, 2014, ISBN 978-3-8362-2873-2, S. 1014 (1306 Seiten, eingeschränkte Vorschau in der Google-Buchsuche).
`:cite-note-almog-60`!53.`! `F0af`_`[↑`#cite-ref-almog-60-0]`_`f Shai Almog: `*Should Oracle Spring Clean JavaFX?`* In: `*dzone.com.`* 22. November 2015, abgerufen am 14. Dezember 2016 (englisch).
`:cite-note-61`!54.`! `F0af`_`[↑`#cite-ref-61]`_`f Michael Thomas: `*Ruhe in Frieden, JavaFX?`* In: `*jaxenter.de.`* 24. November 2015, abgerufen am 14. Dezember 2016.
`:cite-note-62`!55.`! `F0af`_`[↑`#cite-ref-62]`_`f `*iJUG fordert von Oracle ein klares Bekenntnis zu JavaFX.`* In: `*ijug.eu.`* 27. Januar 2016, archiviert vom Original (nicht mehr online verfügbar) am 23. September 2016; abgerufen am 14. Dezember 2016.
`:cite-note-schlosser-63`!56.`! `F0af`_`[↑`#cite-ref-schlosser-63-0]`_`f Hartmut Schlosser: `*Hart aber Fair: Welche Zukunft hat JavaFX?`* In: `*jaxenter.de.`* 22. März 2016, abgerufen am 14. Dezember 2016.
`:cite-note-64`!57.`! `F0af`_`[↑`#cite-ref-64]`_`f `*Interview mit Alexander Casall: „Nur Chuck Norris kann hybride Desktopanwendungen“.`* In: `*jaxenter.de.`* 21. April 2015, abgerufen am 14. Dezember 2016.
>>Anmerkungen
`:cite-note-15`!Anmerkung 1.`! `F0af`_`[↑`#cite-ref-15]`_`f Nicht zu verwechseln mit der Geheimdienstsoftware `F33f`_`[PRISM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PRISM]`_`f
`:cite-note-18`!Anmerkung 2.`! `F0af`_`[↑`#cite-ref-18]`_`f Die main()-Methode ist bei einer JavaFX-Applikation im Grunde nicht notwendig, während sie bei einer normalen Java-Applikation ja den zentralen Einstiegspunkt darstellt. Sie wird von NetBeans nur zur Sicherheit generiert, um im Fall mangelnder JavaFX-Unterstützung auf Zielplattformen den Start der Applikation zu gewährleisten. Netbeans selbst ignoriert die main()-Methode. Siehe: Ralph Steyer: Einführung in JavaFX. 1. Auflage. Springer Vieweg, Wiesbaden 2014, ISBN 978-3-658-02835-0, S. 29, `F33f`_`[doi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digital_Object_Identifier]`_`f:10.1007/978-3-658-02836-7 (361 Seiten).
`:cite-note-22`!Anmerkung 3.`! `F0af`_`[↑`#cite-ref-22]`_`f Der Grund dafür ist, dass die init-Methode – genau wie der Konstruktor der Klasse – noch vom Launcher-Thread der Anwendung aufgerufen wird. UI-Elemente dürfen aber nur im JavaFX-Application-Thread erzeugt und modifiziert werden. Siehe: Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 10 (296 Seiten).
`:cite-note-25`!Anmerkung 4.`! `F0af`_`[↑`#cite-ref-25]`_`f Für eine ausführliche Beschreibung der Klasse Stage siehe: `*Class Stage.`* In: `*docs.oracle.com.`* Abgerufen am 11. Dezember 2016 (englisch). Siehe auch: Anton Epple: JavaFX 8: Grundlagen und fortgeschrittene Techniken. 1. Auflage. dpunkt.verlag, Heidelberg 2015, ISBN 978-3-86490-169-0, S. 11 ff. (296 Seiten).
`:cite-note-38`!Anmerkung 5.`! `F0af`_`[↑`#cite-ref-38]`_`f Im Unterschied dazu sind konsolenbasierte oder ältere grafische Programme oft eine lineare bzw. deterministische Folge von Anweisungen und/oder Eingaben, die nacheinander abgearbeitet werden.
`:cite-note-49`!Anmerkung 6.`! `F0af`_`[↑`#cite-ref-49]`_`f Dies ist vergleichbar mit `F33f`_`[XAML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XAML]`_`f (Extensible Application Markup Language) aus dem .NET-Framework von Microsoft.
`:cite-note-55`!Anmerkung 7.`! `F0af`_`[↑`#cite-ref-55]`_`f Das Tool ist unter folgender URL für Windows, OS X und Linux erhältlich: https://gluonhq.com/products/scene-builder/
`c`F0af`_`[↑ Back to top`#top]`_`f`a